home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termAmigaGuide.c < prev    next >
C/C++ Source or Header  |  1995-01-10  |  9KB  |  420 lines
  1. /*
  2. **    termAmigaGuide.c
  3. **
  4. **    AmigaGuide support routines
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* Local data. */
  13.  
  14. STATIC STRPTR             ContextList[55];
  15. STATIC AMIGAGUIDECONTEXT     Context;
  16. STATIC struct NewAmigaGuide     NewGuide;
  17. STATIC struct Process        *GuideProcess;
  18. STATIC LONG             GuideContextID = CONTEXT_MAIN;
  19.  
  20.     /* GuideServer(VOID):
  21.      *
  22.      *    AmigaGuide server, handles all the signal processing.
  23.      */
  24.  
  25. STATIC VOID __saveds
  26. GuideServer(VOID)
  27. {
  28.         /* Open the help text file asynchronously... */
  29.  
  30.     if(Context = OpenAmigaGuideAsync(&NewGuide,TAG_DONE))
  31.     {
  32.         ULONG    GuideMask,
  33.             Signals;
  34.         BYTE    Done = FALSE;
  35.  
  36.             /* Pick up the signal notification mask. */
  37.  
  38.         GuideMask = AmigaGuideSignal(Context);
  39.  
  40.             /* Clear the context stack. */
  41.  
  42.         SetAmigaGuideContext(Context,0,TAG_DONE);
  43.  
  44.             /* Flag the main process to continue. */
  45.  
  46.         Signal(ThisProcess,SIG_HANDSHAKE);
  47.  
  48.             /* Go into input loop. */
  49.  
  50.         do
  51.         {
  52.                 /* Wait for a signal... */
  53.  
  54.             Signals = Wait(SIG_KILL | GuideMask);
  55.  
  56.                 /* Are we to quit? */
  57.  
  58.             if(Signals & SIG_KILL)
  59.                 Done = TRUE;
  60.  
  61.                 /* Process icoming AmigaGuide messages. */
  62.  
  63.             if(Signals & GuideMask)
  64.             {
  65.                 struct AmigaGuideMsg *GuideMessage;
  66.  
  67.                 while(GuideMessage = GetAmigaGuideMsg(Context))
  68.                     ReplyAmigaGuideMsg(GuideMessage);
  69.             }
  70.         }
  71.         while(!Done);
  72.  
  73.             /* Close the help text file. */
  74.  
  75.         CloseAmigaGuide(Context);
  76.     }
  77.  
  78.         /* Lock & quit. */
  79.  
  80.     Forbid();
  81.  
  82.     GuideProcess = NULL;
  83.  
  84.     Signal(ThisProcess,SIG_HANDSHAKE);
  85. }
  86.  
  87.     /* GuideLaunch(LONG ContextID):
  88.      *
  89.      *    Launch the AmigaGuide help file server.
  90.      */
  91.  
  92. STATIC BYTE
  93. GuideLaunch(LONG ContextID)
  94. {
  95.         /* Is the main program running and is this the
  96.          * main program to make the call?
  97.          */
  98.  
  99.     if(Window && SysBase -> ThisTask == ThisProcess)
  100.     {
  101.             /* Is the help file server already running? */
  102.  
  103.         if(!GuideProcess)
  104.         {
  105.             if(!AmigaGuideBase)
  106.                 AmigaGuideBase = OpenLibrary("amigaguide.library",0);
  107.  
  108.             if(AmigaGuideBase)
  109.             {
  110.                 BYTE IsValidFile = TRUE;
  111.  
  112.                     /* Do we have a valid AmigaGuide file name? */
  113.  
  114.                 if(Config -> PathConfig -> HelpFile[0])
  115.                 {
  116.                     if(!GetFileSize(Config -> PathConfig -> HelpFile))
  117.                         IsValidFile = FALSE;
  118.                 }
  119.                 else
  120.                     IsValidFile = FALSE;
  121.  
  122.                     /* Do we have a valid AmigaGuide file name? */
  123.  
  124.                 if(!IsValidFile)
  125.                 {
  126.                         /* Don't pop up the file requester if any
  127.                          * time-critical services are currently running!
  128.                          */
  129.  
  130.                     if(ContextID == CONTEXT_TRANSFER || ContextID == CONTEXT_DIAL)
  131.                     {
  132.                         DisplayBeep(Window -> WScreen);
  133.  
  134.                         return(FALSE);
  135.                     }
  136.                     else
  137.                     {
  138.                         struct FileRequester    *FileRequest;
  139.                         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  140.                                      DummyName[40];
  141.  
  142.                             /* Provide a default name if necessary. */
  143.  
  144.                         if(!Config -> PathConfig -> HelpFile[0])
  145.                             strcpy(Config -> PathConfig -> HelpFile,"PROGDIR:term.guide");
  146.  
  147.                             /* Block the windows. */
  148.  
  149.                         BlockWindows();
  150.  
  151.                             /* Get file and path name. */
  152.  
  153.                         strcpy(DummyBuffer,Config -> PathConfig -> HelpFile);
  154.  
  155.                         if(DummyBuffer[0])
  156.                         {
  157.                             STRPTR DummyChar;
  158.  
  159.                             if(FilePart(DummyBuffer) == DummyBuffer)
  160.                             {
  161.                                 strcpy(DummyName,DummyBuffer);
  162.  
  163.                                 DummyBuffer[0] = 0;
  164.                             }
  165.                             else
  166.                             {
  167.                                 strcpy(DummyName,FilePart(DummyBuffer));
  168.  
  169.                                 DummyChar = PathPart(DummyBuffer);
  170.  
  171.                                 *DummyChar = 0;
  172.                             }
  173.                         }
  174.                         else
  175.                             DummyName[0] = 0;
  176.  
  177.                             /* Get the help text file name. */
  178.  
  179.                         if(FileRequest = GetFile(Window,LocaleString(MSG_PATHPANEL_SELECT_HELP_FILE_TXT),DummyBuffer,DummyName,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  180.                         {
  181.                             if(GetFileSize(DummyBuffer))
  182.                             {
  183.                                 strcpy(Config -> PathConfig -> HelpFile,DummyBuffer);
  184.  
  185.                                 IsValidFile = TRUE;
  186.                             }
  187.  
  188.                             FreeAslRequest(FileRequest);
  189.                         }
  190.  
  191.                             /* Release the windows... */
  192.  
  193.                         ReleaseWindows();
  194.                     }
  195.                 }
  196.  
  197.                     /* Do we finally have a valid file name? */
  198.  
  199.                 if(IsValidFile)
  200.                 {
  201.                     STATIC LONG NodeTable[] =
  202.                     {
  203.                         MSG_TERMAMIGAGUIDE_NODE_00_TXT,
  204.                         MSG_TERMAMIGAGUIDE_NODE_01_TXT,
  205.                         MSG_TERMAMIGAGUIDE_NODE_02_TXT,
  206.                         MSG_TERMAMIGAGUIDE_NODE_03_TXT,
  207.                         MSG_TERMAMIGAGUIDE_NODE_04_TXT,
  208.                         MSG_TERMAMIGAGUIDE_NODE_05_TXT,
  209.                         MSG_TERMAMIGAGUIDE_NODE_06_TXT,
  210.                         MSG_TERMAMIGAGUIDE_NODE_07_TXT,
  211.                         MSG_TERMAMIGAGUIDE_NODE_08_TXT,
  212.                         MSG_TERMAMIGAGUIDE_NODE_09_TXT,
  213.                         MSG_TERMAMIGAGUIDE_NODE_10_TXT,
  214.                         MSG_TERMAMIGAGUIDE_NODE_11_TXT,
  215.                         MSG_TERMAMIGAGUIDE_NODE_12_TXT,
  216.                         MSG_TERMAMIGAGUIDE_NODE_13_TXT,
  217.                         MSG_TERMAMIGAGUIDE_NODE_14_TXT,
  218.                         MSG_TERMAMIGAGUIDE_NODE_15_TXT,
  219.                         MSG_TERMAMIGAGUIDE_NODE_16_TXT,
  220.                         MSG_TERMAMIGAGUIDE_NODE_17_TXT,
  221.                         MSG_TERMAMIGAGUIDE_NODE_18_TXT,
  222.                         MSG_TERMAMIGAGUIDE_NODE_19_TXT,
  223.                         MSG_TERMAMIGAGUIDE_NODE_20_TXT,
  224.                         MSG_TERMAMIGAGUIDE_NODE_21_TXT,
  225.                         MSG_TERMAMIGAGUIDE_NODE_22_TXT,
  226.                         MSG_TERMAMIGAGUIDE_NODE_23_TXT,
  227.                         MSG_TERMAMIGAGUIDE_NODE_24_TXT,
  228.                         MSG_TERMAMIGAGUIDE_NODE_25_TXT,
  229.                         MSG_TERMAMIGAGUIDE_NODE_26_TXT,
  230.                         MSG_TERMAMIGAGUIDE_NODE_27_TXT,
  231.                         MSG_TERMAMIGAGUIDE_NODE_28_TXT,
  232.                         MSG_TERMAMIGAGUIDE_NODE_29_TXT,
  233.                         MSG_TERMAMIGAGUIDE_NODE_30_TXT,
  234.                         MSG_TERMAMIGAGUIDE_NODE_31_TXT,
  235.                         MSG_TERMAMIGAGUIDE_NODE_32_TXT,
  236.                         MSG_TERMAMIGAGUIDE_NODE_33_TXT,
  237.                         MSG_TERMAMIGAGUIDE_NODE_34_TXT,
  238.                         MSG_TERMAMIGAGUIDE_NODE_35_TXT,
  239.                         MSG_TERMAMIGAGUIDE_NODE_36_TXT,
  240.                         MSG_TERMAMIGAGUIDE_NODE_37_TXT,
  241.                         MSG_TERMAMIGAGUIDE_NODE_38_TXT,
  242.                         MSG_TERMAMIGAGUIDE_NODE_39_TXT,
  243.                         MSG_TERMAMIGAGUIDE_NODE_40_TXT,
  244.                         MSG_TERMAMIGAGUIDE_NODE_41_TXT,
  245.                         MSG_TERMAMIGAGUIDE_NODE_42_TXT,
  246.                         MSG_TERMAMIGAGUIDE_NODE_43_TXT,
  247.                         MSG_TERMAMIGAGUIDE_NODE_44_TXT,
  248.                         MSG_TERMAMIGAGUIDE_NODE_45_TXT,
  249.                         MSG_TERMAMIGAGUIDE_NODE_46_TXT,
  250.                         MSG_TERMAMIGAGUIDE_NODE_47_TXT,
  251.                         MSG_TERMAMIGAGUIDE_NODE_48_TXT,
  252.                         MSG_TERMAMIGAGUIDE_NODE_49_TXT,
  253.                         MSG_TERMAMIGAGUIDE_NODE_50_TXT,
  254.                         MSG_TERMAMIGAGUIDE_NODE_51_TXT,
  255.                         MSG_TERMAMIGAGUIDE_NODE_52_TXT,
  256.                         MSG_TERMAMIGAGUIDE_NODE_53_TXT,
  257.  
  258.                         -1
  259.                     };
  260.  
  261.                         /* Provide the context node names (note: language
  262.                          * specific!).
  263.                          */
  264.  
  265.                     LocalizeStringTable(ContextList,NodeTable);
  266.  
  267.                         /* Clear the instance. */
  268.  
  269.                     memset(&NewGuide,0,sizeof(struct NewAmigaGuide));
  270.  
  271.                         /* Fill in the structure. */
  272.  
  273.                     NewGuide . nag_BaseName        = "termHelp";
  274.                     NewGuide . nag_Name        = Config -> PathConfig -> HelpFile;
  275.                     NewGuide . nag_ClientPort    = "TERM_HELP";
  276.                     NewGuide . nag_Context        = ContextList;
  277.                     NewGuide . nag_Screen        = Window -> WScreen;
  278.  
  279.                         /* Launch the server process and
  280.                          * wait for reply.
  281.                          */
  282.  
  283.                     Forbid();
  284.  
  285.                     if(GuideProcess = CreateNewProcTags(
  286.                         NP_Entry,    GuideServer,
  287.                         NP_Name,    "term AmigaGuide Process",
  288.                     TAG_DONE))
  289.                     {
  290.                         ClrSignal(SIG_HANDSHAKE);
  291.  
  292.                         Wait(SIG_HANDSHAKE);
  293.                     }
  294.  
  295.                     Permit();
  296.                 }
  297.             }
  298.         }
  299.  
  300.             /* Pop the main screen to the front if necessary. */
  301.  
  302.         if(GuideProcess)
  303.         {
  304.             ScreenToFront(Window -> WScreen);
  305.  
  306.             return(TRUE);
  307.         }
  308.         else
  309.         {
  310.             if(AmigaGuideBase)
  311.             {
  312.                 CloseLibrary(AmigaGuideBase);
  313.  
  314.                 AmigaGuideBase = NULL;
  315.             }
  316.  
  317.             DisplayBeep(Window -> WScreen);
  318.  
  319.             return(FALSE);
  320.         }
  321.     }
  322.     else
  323.     {
  324.         if(GuideProcess && Window)
  325.         {
  326.             ScreenToFront(Window -> WScreen);
  327.  
  328.             return(TRUE);
  329.         }
  330.         else
  331.             return(FALSE);
  332.     }
  333. }
  334.  
  335.     /* GuideCleanup():
  336.      *
  337.      *    Terminate the AmigaGuide server and free the
  338.      *    associated resources.
  339.      */
  340.  
  341. VOID
  342. GuideCleanup()
  343. {
  344.     if(GuideProcess)
  345.     {
  346.         Forbid();
  347.  
  348.         Signal(GuideProcess,SIG_KILL);
  349.  
  350.         ClrSignal(SIG_HANDSHAKE);
  351.  
  352.         Wait(SIG_HANDSHAKE);
  353.  
  354.         Permit();
  355.     }
  356.  
  357.     if(AmigaGuideBase)
  358.     {
  359.         CloseLibrary(AmigaGuideBase);
  360.  
  361.         AmigaGuideBase = NULL;
  362.     }
  363. }
  364.  
  365.     /* GuideContext(LONG NewContextID):
  366.      *
  367.      *    Set the global AmigaGuide context.
  368.      */
  369.  
  370. VOID __regargs
  371. GuideContext(LONG NewContextID)
  372. {
  373.     GuideContextID = NewContextID;
  374. }
  375.  
  376. ULONG __saveds __asm
  377. GuideSetupHook(register __a0 struct Hook *Hook,register __a1 struct IBox *Bounds,register __a2 HelpMsg *HelpMessage)
  378. {
  379.     if(GuideLaunch(GuideContextID))
  380.     {
  381.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  382.         SendAmigaGuideContext(Context,TAG_DONE);
  383.  
  384.         return(TRUE);
  385.     }
  386.     else
  387.         return(FALSE);
  388. }
  389.  
  390.     /* GuideSetup():
  391.      *
  392.      *    Try to display the currently selected AmigaGuide
  393.      *    help text.
  394.      */
  395.  
  396. VOID
  397. GuideSetup()
  398. {
  399.     if(GuideLaunch(GuideContextID))
  400.     {
  401.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  402.         SendAmigaGuideContext(Context,TAG_DONE);
  403.     }
  404. }
  405.  
  406.     /* GuideDisplay(LONG ContextID):
  407.      *
  408.      *    Try to display an AmigaGuide help text.
  409.      */
  410.  
  411. VOID __regargs
  412. GuideDisplay(LONG ContextID)
  413. {
  414.     if(GuideLaunch(ContextID))
  415.     {
  416.         SetAmigaGuideContext(Context,ContextID,TAG_DONE);
  417.         SendAmigaGuideContext(Context,TAG_DONE);
  418.     }
  419. }
  420.